// 检查是否在模拟模式
// 修改后
import { isMockMode, realBaseURL } from '../config';

// 基础URL配置 - 使用配置文件中的远程服务器地址
const BASE_URL = realBaseURL;

// 封装uni.request
const request = {
  // 发送请求的基础方法
  send(url, method, data, headers = {}) {
    // 打印当前是否为模拟模式
    console.log('当前是否为模拟模式:', isMockMode);
    // 在模拟模式下，直接返回一个失败的Promise
    // 这样调用方会使用auth.js中的模拟实现
    if (isMockMode) {
      return new Promise((resolve, reject) => {
        reject(new Error('Mock mode enabled'));
      });
    }
    
    // 合并默认headers和自定义headers
    const defaultHeaders = {
      'Content-Type': 'application/json',
      ...headers
    }
    
    // 从本地存储获取token
    const token = uni.getStorageSync('token')
    if (token) {
      defaultHeaders['Authorization'] = `Bearer ${token}`
    }
    
    // 打印请求前的详细信息
    console.log('=== utils/api/request.js 开始发送请求 ===');
    console.log('请求URL:', BASE_URL + url);
    console.log('请求方法:', method);
    console.log('请求头信息:', defaultHeaders);
    console.log('请求数据:', data);
    
    // 重试计数器
    let retryCount = 0;
    const maxRetries = 2;
    
    // 发送请求的内部函数
    const sendRequest = () => {
      return new Promise((resolve, reject) => {
        uni.request({
          url: BASE_URL + url,
          method,
          data,
          header: defaultHeaders,
          timeout: 15000, // 增加超时时间
          sslVerify: false, // 确保SSL证书验证始终关闭
          success: (res) => {
            // 打印完整响应信息
            console.log('=== utils/api/request.js 请求响应信息 ===');
            console.log('HTTP状态码:', res.statusCode);
            console.log('响应头:', res.header);
            console.log('响应数据:', res.data);
            
            // 统一处理响应
            if (res.statusCode === 200) {
              const result = res.data
              if (result.code !== 200) {
                // 根据错误码进行相应处理
                switch (result.code) {
                  case 401:
                    // token过期或未登录
                    uni.showToast({
                      title: '登录已过期，请重新登录',
                      icon: 'none'
                    })
                    // 清除本地存储的token
                    uni.removeStorageSync('token')
                    // 跳转到登录页面
                    uni.redirectTo({
                      url: '/pages/login/login'
                    })
                    break
                  case 403:
                    uni.showToast({
                      title: '权限不足',
                      icon: 'none'
                    })
                    break
                  case 404:
                    uni.showToast({
                      title: '请求资源不存在',
                      icon: 'none'
                    })
                    break
                  case 500:
                    uni.showToast({
                      title: '服务器错误',
                      icon: 'none'
                    })
                    break
                  default:
                    uni.showToast({
                      title: result.msg || '请求失败',
                      icon: 'none'
                    })
                }
                reject(result)
              } else {
                resolve(result)
              }
            } else {
              // 处理HTTP状态码错误
              let errorMessage = `请求失败: ${res.statusCode}`
              
              // 为常见的HTTP状态码提供更具体的错误信息
              if (res.statusCode === 422) {
                errorMessage = '请求参数格式不正确，请检查输入'
              } else if (res.statusCode === 401) {
                errorMessage = '登录已过期，请重新登录'
                // 清除本地存储的token
                uni.removeStorageSync('token')
                // 跳转到登录页面
                setTimeout(() => {
                  uni.redirectTo({
                    url: '/pages/login/login'
                  })
                }, 1500)
              } else if (res.statusCode === 500) {
                errorMessage = '服务器内部错误，请稍后重试'
              }
              
              uni.showToast({
                title: errorMessage,
                icon: 'none'
              })
              reject(new Error(`HTTP错误: ${res.statusCode}`))
            }
          },
          fail: (err) => {
            // 打印失败信息
            console.error('=== utils/api/request.js 请求失败详情 ===');
            console.error('错误信息:', JSON.stringify(err));
            
            // 处理重试逻辑
            if (retryCount < maxRetries && 
                err.errMsg && 
                (err.errMsg.includes('network') || 
                 err.errMsg.includes('timeout') || 
                 err.errMsg.includes('certificate') ||
                 err.errMsg.includes('SSL'))) {
              
              retryCount++;
              console.log(`请求失败，正在进行第${retryCount}次重试...`);
              
              // 指数退避重试
              setTimeout(() => {
                sendRequest()
                  .then(resolve)
                  .catch(reject);
              }, retryCount * 1000);
            } else {
              // 处理网络错误等
              // 在模拟模式下不显示错误提示
              if (!isMockMode) {
                let errorMessage = '网络错误，请检查网络连接';
                if (err.errMsg && err.errMsg.includes('certificate')) {
                  errorMessage = 'SSL证书验证失败，请确认服务器配置正确';
                } else if (err.errMsg && err.errMsg.includes('timeout')) {
                  errorMessage = '请求超时，请检查网络连接';
                }
                
                uni.showToast({
                  title: errorMessage,
                  icon: 'none'
                })
              }
              reject(err)
            }
          }
        });
      });
    };
    
    // 开始发送请求
    return sendRequest();
  },
  
  // 封装GET请求
  get(url, params = {}) {
    // 将params参数拼接到url上
    let fullUrl = url
    const queryParams = Object.keys(params)
      .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
      .join('&')
    
    if (queryParams) {
      fullUrl += (url.includes('?') ? '&' : '?') + queryParams
    }
    
    return this.send(fullUrl, 'GET')
  },
  
  // 封装POST请求
  post(url, data = {}, headers = {}) {
    return this.send(url, 'POST', data, headers)
  },
  
  // 封装PUT请求
  put(url, data = {}, headers = {}) {
    return this.send(url, 'PUT', data, headers)
  },
  
  // 封装DELETE请求
  delete(url, headers = {}) {
    return this.send(url, 'DELETE', {}, headers)
  },
  
  // 文件上传
  upload(url, formData) {
    return new Promise((resolve, reject) => {
      // 从本地存储获取token
      const token = uni.getStorageSync('token')
      const headers = {
        'Authorization': token ? `Bearer ${token}` : ''
      }
      
      uni.uploadFile({
        url: BASE_URL + url,
        filePath: formData.filePath,
        name: formData.name || 'file',
        formData: formData.formData || {},
        header: headers,
        success: (res) => {
          if (res.statusCode === 200) {
            try {
              const result = JSON.parse(res.data)
              resolve(result)
            } catch (e) {
              resolve(res.data)
            }
          } else {
            uni.showToast({
              title: `上传失败: ${res.statusCode}`,
              icon: 'none'
            })
            reject(new Error(`上传失败: ${res.statusCode}`))
          }
        },
        fail: (err) => {
          uni.showToast({
            title: '上传失败，请检查网络连接',
            icon: 'none'
          })
          reject(err)
        }
      })
    })
  },
  
  // 文件下载
  download(url) {
    return new Promise((resolve, reject) => {
      // 从本地存储获取token
      const token = uni.getStorageSync('token')
      const headers = {
        'Authorization': token ? `Bearer ${token}` : ''
      }
      
      console.log('开始下载文件:', BASE_URL + url)
      
      uni.downloadFile({
        url: BASE_URL + url,
        header: headers,
        timeout: 60000, // 60秒超时
        success: (res) => {
          console.log('下载响应:', res)
          if (res.statusCode === 200) {
            console.log('文件下载成功，临时路径:', res.tempFilePath)
            resolve(res.tempFilePath)
          } else {
            console.error('下载失败，状态码:', res.statusCode)
            uni.showToast({
              title: `下载失败: ${res.statusCode}`,
              icon: 'none'
            })
            reject(new Error(`下载失败: ${res.statusCode}`))
          }
        },
        fail: (err) => {
          console.error('下载失败:', err)
          uni.showToast({
            title: '下载失败，请检查网络连接',
            icon: 'none'
          })
          reject(err)
        }
      })
    })
  }
}

export default request